const sqlite3 = require('sqlite3').verbose();

/**
 * SQLite 工具类，提供数据库的增删改查及表创建功能
 * 使用单例模式，确保整个应用只维护一个数据库连接
 */
class SqlLiteUtil {
    /**
     * 私有静态实例，用于实现单例模式
     * @type {SqlLiteUtil | null}
     */
    static #instance = null;

    /**
     * 私有数据库对象，仅在实例化时创建一次
     * @type {sqlite3.Database}
     */
    #db = null;

    /**
     * 构造函数，初始化数据库连接
     * @param {string} dbPath - 数据库文件路径，默认为 Electron userData 目录下的 app.db 或内存数据库
     * @returns {SqlLiteUtil} 单例实例
     */
    constructor(dbPath) {
        // 如果实例已存在，直接返回现有实例
        if (SqlLiteUtil.#instance) {
            return SqlLiteUtil.#instance;
        }

        // 使用 Electron 的 userData 目录存储数据库文件，确保跨平台兼容
        const { app } = require('electron') || {};
        this.dbPath = dbPath || (app ? app.getPath('userData') + '/app.db' : ':memory:');
        this.#db = new sqlite3.Database(this.dbPath, (err) => {
            if (err) {
                console.error('Database connection error:', err.message);
            } else {
                console.log('Connected to SQLite database at:', this.dbPath);
            }
        });

        // 将当前实例保存为单例
        SqlLiteUtil.#instance = this;

        return this;
    }



    CHAT_TABLE = {
        name: 'chat',
        structure: [
            { name: 'id', type: 'INTEGER', options: 'PRIMARY KEY AUTOINCREMENT' },
            { name: 'title', type: 'TEXT' },
            { name: 'create_time', type: 'TEXT' }
        ]
    }

    CHAT_LIST_TABLE = {
        name: 'chat_list',
        structure: [
            { name: 'id', type: 'INTEGER', options: 'PRIMARY KEY AUTOINCREMENT' },
            { name: 'chat_id', type: 'INTEGER' },
            { name: 'type', type: 'INTEGER' },
            { name: 'content', type: 'TEXT' },
            { name: 'create_time', type: 'TEXT' }
        ]
    }


    TABLE_LIST = [
        this.CHAT_TABLE,
        this.CHAT_LIST_TABLE,

    ]


    /**
     * 初始化数据库
     */
    initDatabase() {
        this.TABLE_LIST.forEach((table) => {

            /**
             * 初始表不存在则进行创建
             */
            this.tableExists(table.name).then((exists) => {
                if (!exists) {
                    this.createTable(table.name , table.structure).then(() => {
                        console.log(`${table.name} 表初始化创建成功！`);
                    }).catch((err) => {
                        console.error(`${table.name}表创建失败：${err.message}`);
                    })

                } else {
                    console.log(`${table.name} 表已存在！不予创建`);
                }
            })

        })
    }

    /**
     * 判断数据表是否存在
     * @param {string} tableName - 要检查的表名
     * @returns {Promise<boolean>} 表是否存在
     */
    async tableExists(tableName) {
        return new Promise((resolve, reject) => {
            // 查询 sqlite_master 表，检查指定表是否存在
            const sql = `SELECT COUNT(*) as count FROM sqlite_master WHERE type='table' AND name=?`;
            this.#db.get(sql, [tableName], (err, row) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(row.count > 0); // 如果 count > 0，表存在
                }
            });
        });
    }

    /**
     * 创建表
     * @param {string} tableName - 表名
     * @param {Array<Object>} columns - 列定义数组，包含 { name, type, options }
     * @returns {Promise<string>} 成功消息
     */
    createTable(tableName, columns) {
        return new Promise((resolve, reject) => {
            const columnDefs = columns.map(col => `${col.name} ${col.type} ${col.options || ''}`).join(', ');
            const sql = `CREATE TABLE IF NOT EXISTS ${tableName} (${columnDefs})`;
            this.#db.run(sql, (err) => {
                if (err) reject(err);
                else resolve(`Table ${tableName} created or already exists`);
            });
        });
    }

    /**
     * 插入数据
     * @param {string} tableName - 表名
     * @param {Object} data - 插入的数据对象，键为列名，值为值
     * @returns {Promise<Object>} 包含插入的 ID 和影响行数的对象
     */
    insert(tableName, data) {
        return new Promise((resolve, reject) => {
            const columns = Object.keys(data).join(', ');
            const placeholders = Object.keys(data).map(() => '?').join(', ');
            const sql = `INSERT INTO ${tableName} (${columns}) VALUES (${placeholders})`;
            this.#db.run(sql, Object.values(data), function (err) {
                if (err) reject(err);
                else resolve({ id: this.lastID, affectedRows: this.changes });
            });
        });
    }

    /**
     * 更新数据
     * @param {string} tableName - 表名
     * @param {Object} data - 更新的数据对象
     * @param {string} condition - WHERE 条件
     * @returns {Promise<Object>} 包含影响行数的对象
     */
    update(tableName, data, condition) {
        return new Promise((resolve, reject) => {
            const setClause = Object.keys(data).map(key => `${key} = ?`).join(', ');
            const sql = `UPDATE ${tableName} SET ${setClause} WHERE ${condition}`;
            this.#db.run(sql, Object.values(data), function (err) {
                if (err) reject(err);
                else resolve({ affectedRows: this.changes });
            });
        });
    }

    /**
     * 删除数据
     * @param {string} tableName - 表名
     * @param {string} condition - WHERE 条件
     * @returns {Promise<Object>} 包含影响行数的对象
     */
    delete(tableName, condition) {
        return new Promise((resolve, reject) => {
            const sql = `DELETE FROM ${tableName} WHERE ${condition}`;
            this.#db.run(sql, [], function (err) {
                if (err) reject(err);
                else resolve({ affectedRows: this.changes });
            });
        });
    }

    /**
     * 查询数据
     * @param {string} tableName - 表名
     * @param {string} columns - 查询的列名，默认为 '*'
     * @param {string} condition - WHERE 条件，默认为 '1=1'
     * @returns {Promise<Array>} 查询结果数组
     */
    select(tableName, columns = '*', condition = '1=1') {
        return new Promise((resolve, reject) => {
            const sql = `SELECT ${columns} FROM ${tableName} WHERE ${condition}`;
            this.#db.all(sql, [], (err, rows) => {
                if (err) reject(err);
                else resolve(rows);
            });
        });
    }

    /**
     * 关闭数据库连接
     * @returns {Promise<void>} 关闭连接后的异步操作
     */
    close() {
        return new Promise((resolve) => {
            if (this.#db) {
                this.#db.close(() => {
                    console.log('Database connection closed');
                    SqlLiteUtil.#instance = null; // 关闭后清空单例实例
                    this.#db = null;
                    resolve();
                });
            } else {
                resolve();
            }
        });
    }
}

// 导出类（用于 Electron 主进程或模块化项目）
module.exports = SqlLiteUtil;

// 示例用法（可选，注释掉以避免直接执行）
/*
const db = new SqlLiteUtil('path/to/your.db');

(async () => {
  try {
    // 创建用户表
    await db.createTable('users', [
      { name: 'id', type: 'INTEGER', options: 'PRIMARY KEY AUTOINCREMENT' },
      { name: 'name', type: 'TEXT' },
      { name: 'age', type: 'INTEGER' }
    ]);

    // 插入数据
    await db.insert('users', { name: 'Alice', age: 25 });

    // 查询数据
    const users = await db.select('users', '*', 'age > 20');
    console.log('Users:', users);

    // 更新数据
    await db.update('users', { age: 26 }, 'name = "Alice"');

    // 删除数据
    await db.delete('users', 'age = 26');

    // 关闭连接
    await db.close();
  } catch (err) {
    console.error('Error:', err);
  }
})();
*/
